﻿//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Lens.Translations {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class CompilerMessages {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal CompilerMessages() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Lens.Translations.CompilerMessages", typeof(CompilerMessages).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3001: Cannot use object of type &apos;{0}&apos; as a value for parameter of type &apos;{1}&apos;!.
        /// </summary>
        public static string ArgumentTypeMismatch {
            get {
                return ResourceManager.GetString("ArgumentTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3002: Cannot add object of type &apos;{0}&apos; to array of type &apos;{1}&apos;!.
        /// </summary>
        public static string ArrayElementTypeMismatch {
            get {
                return ResourceManager.GetString("ArrayElementTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3003: Array initializer must contain at least one object! Use explicit constructor to create an empty array..
        /// </summary>
        public static string ArrayEmpty {
            get {
                return ResourceManager.GetString("ArrayEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3004: Cannot use an expression of type &apos;{0}&apos; as array size specifier because it is not assignable to System.Int32!.
        /// </summary>
        public static string ArraySizeNotInt {
            get {
                return ResourceManager.GetString("ArraySizeNotInt", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3005: Array type cannot be inferred! Use type casting to specify element types..
        /// </summary>
        public static string ArrayTypeUnknown {
            get {
                return ResourceManager.GetString("ArrayTypeUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3006: Cannot create a callable object from a method with more than 16 arguments!.
        /// </summary>
        public static string CallableTooManyArguments {
            get {
                return ResourceManager.GetString("CallableTooManyArguments", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3007: Delegate types &apos;{0}&apos; and &apos;{1}&apos; do not have matching argument types!.
        /// </summary>
        public static string CastDelegateArgTypesMismatch {
            get {
                return ResourceManager.GetString("CastDelegateArgTypesMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3008: Return types mismatch for &apos;{0}&apos; and &apos;{1}&apos;: &apos;{2}&apos; expected, &apos;{3}&apos; given!.
        /// </summary>
        public static string CastDelegateReturnTypesMismatch {
            get {
                return ResourceManager.GetString("CastDelegateReturnTypesMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3009: Cannot cast a null to type &apos;{0}&apos; because it is a value type!.
        /// </summary>
        public static string CastNullValueType {
            get {
                return ResourceManager.GetString("CastNullValueType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3010: Cannot cast object of type &apos;{0}&apos; to type &apos;{1}&apos;!.
        /// </summary>
        public static string CastTypesMismatch {
            get {
                return ResourceManager.GetString("CastTypesMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3011: This catch clause is unreachable, because all exceptions of type &apos;{0}&apos; will be intercepted by a catch clause for &apos;{1}&apos; defined earlier in code!.
        /// </summary>
        public static string CatchClauseUnreachable {
            get {
                return ResourceManager.GetString("CatchClauseUnreachable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3012: Type &apos;{0}&apos; has already been used in a catch clause of current try block!.
        /// </summary>
        public static string CatchTypeDuplicate {
            get {
                return ResourceManager.GetString("CatchTypeDuplicate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3013: Type &apos;{0}&apos; cannot be used in catch clause because it does not derive from System.Exception!.
        /// </summary>
        public static string CatchTypeNotException {
            get {
                return ResourceManager.GetString("CatchTypeNotException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3014: Cannot closure an implicit variable!.
        /// </summary>
        public static string ClosureImplicit {
            get {
                return ResourceManager.GetString("ClosureImplicit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3015: Cannot closure argument &apos;{0}&apos; because it is passed by reference!.
        /// </summary>
        public static string ClosureRef {
            get {
                return ResourceManager.GetString("ClosureRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3151: Expression has type &apos;{0}&apos;, which is not nullable!.
        /// </summary>
        public static string CoalesceOperatorLeftNotNull {
            get {
                return ResourceManager.GetString("CoalesceOperatorLeftNotNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3152: Type &apos;{0}&apos; is not compatible with &apos;{1}&apos;!.
        /// </summary>
        public static string CoalesceOperatorTypeMismatch {
            get {
                return ResourceManager.GetString("CoalesceOperatorTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3016: Code block contains no statements!.
        /// </summary>
        public static string CodeBlockEmpty {
            get {
                return ResourceManager.GetString("CodeBlockEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3017: A declaration of a variable or a constant cannot be the last statement in a code block!.
        /// </summary>
        public static string CodeBlockLastVar {
            get {
                return ResourceManager.GetString("CodeBlockLastVar", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3018: No best common type found for return types of condition branches: &apos;{0}&apos; and &apos;{1}&apos; respectively..
        /// </summary>
        public static string ConditionInconsistentTyping {
            get {
                return ResourceManager.GetString("ConditionInconsistentTyping", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3019: Expression of type &apos;{0}&apos; cannot be used as a condition because it is not castable to a boolean!.
        /// </summary>
        public static string ConditionTypeMismatch {
            get {
                return ResourceManager.GetString("ConditionTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3020: Constant variables cannot be passed by reference!.
        /// </summary>
        public static string ConstantByRef {
            get {
                return ResourceManager.GetString("ConstantByRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3021: Constant division by zero!.
        /// </summary>
        public static string ConstantDivisionByZero {
            get {
                return ResourceManager.GetString("ConstantDivisionByZero", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3022: Result of the constant expression overflows its type!.
        /// </summary>
        public static string ConstantOverflow {
            get {
                return ResourceManager.GetString("ConstantOverflow", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3023: A constructor must not be marked as static!.
        /// </summary>
        public static string ConstructorStatic {
            get {
                return ResourceManager.GetString("ConstructorStatic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3024: Context #{0} does not exist!.
        /// </summary>
        public static string ContextNotFound {
            get {
                return ResourceManager.GetString("ContextNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3025: Context #{0} has been unregistered!.
        /// </summary>
        public static string ContextUnregistered {
            get {
                return ResourceManager.GetString("ContextUnregistered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3026: Invoking a delegate of type &apos;{0}&apos; requires {1} arguments, {2} given instead!.
        /// </summary>
        public static string DelegateArgumentsCountMismatch {
            get {
                return ResourceManager.GetString("DelegateArgumentsCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3027: Delegates of types &apos;{0}&apos; and &apos;{1}&apos; cannot be combined because their signatures are incompatible!.
        /// </summary>
        public static string DelegatesNotCombinable {
            get {
                return ResourceManager.GetString("DelegatesNotCombinable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3028: Dictionary initializer must contain at least one key-value pair! Use explicit constructor to create an empty dictionary..
        /// </summary>
        public static string DictionaryEmpty {
            get {
                return ResourceManager.GetString("DictionaryEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3029: Cannot add a key of type &apos;{0}&apos; to Dictionary&lt;{1}, {2}&gt;!.
        /// </summary>
        public static string DictionaryKeyTypeMismatch {
            get {
                return ResourceManager.GetString("DictionaryKeyTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3030: Dictionary type cannot be inferred! Use type casting to specify element types..
        /// </summary>
        public static string DictionaryTypeUnknown {
            get {
                return ResourceManager.GetString("DictionaryTypeUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3031: Cannot add a value of type &apos;{0}&apos; to Dictionary&lt;{1}, {2}&gt;!.
        /// </summary>
        public static string DictionaryValueTypeMismatch {
            get {
                return ResourceManager.GetString("DictionaryValueTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3032: &apos;{0}.{1}&apos; cannot be accessed from static context!.
        /// </summary>
        public static string DynamicMemberFromStaticContext {
            get {
                return ResourceManager.GetString("DynamicMemberFromStaticContext", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3149: Event cannot be used as an expression!.
        /// </summary>
        public static string EventAsExpr {
            get {
                return ResourceManager.GetString("EventAsExpr", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3033: Expression of type &apos;{0}&apos; cannot be used in &apos;using&apos; block because it does not implement the &apos;IDisposable&apos; interface!.
        /// </summary>
        public static string ExpressionNotIDisposable {
            get {
                return ResourceManager.GetString("ExpressionNotIDisposable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3034: Expression type cannot be inferred! Please use type casting to specify actual type..
        /// </summary>
        public static string ExpressionNull {
            get {
                return ResourceManager.GetString("ExpressionNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3035: Expression that returns a value is expected!.
        /// </summary>
        public static string ExpressionVoid {
            get {
                return ResourceManager.GetString("ExpressionVoid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3036: Type &apos;{0}&apos; already contains field named &apos;{1}&apos;!.
        /// </summary>
        public static string FieldRedefinition {
            get {
                return ResourceManager.GetString("FieldRedefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3037: Type &apos;{0}&apos; cannot be used as range limit because it is not an integer!.
        /// </summary>
        public static string ForeachRangeNotInteger {
            get {
                return ResourceManager.GetString("ForeachRangeNotInteger", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3038: Cannot create a range from expressions of types &apos;{0}&apos; and &apos;{1}&apos;!.
        /// </summary>
        public static string ForeachRangeTypeMismatch {
            get {
                return ResourceManager.GetString("ForeachRangeTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3039: There is more than one suitable override of function &apos;{0}&apos;! Please use type casting to specify the exact override..
        /// </summary>
        public static string FunctionInvocationAmbiguous {
            get {
                return ResourceManager.GetString("FunctionInvocationAmbiguous", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3040: No function named &apos;{0}&apos; with suitable arguments is declared!.
        /// </summary>
        public static string FunctionNotFound {
            get {
                return ResourceManager.GetString("FunctionNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3041: A function named &apos;{0}&apos; with identical set of arguments has already been defined!.
        /// </summary>
        public static string FunctionRedefinition {
            get {
                return ResourceManager.GetString("FunctionRedefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3042: Number of generic arguments does not match!.
        /// </summary>
        public static string GenericArgCountMismatch {
            get {
                return ResourceManager.GetString("GenericArgCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3043: Generic argument &apos;{0}&apos; has mismatched values: &apos;{1}&apos; and &apos;{2}&apos;!.
        /// </summary>
        public static string GenericArgMismatch {
            get {
                return ResourceManager.GetString("GenericArgMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3044: Cannot apply generic arguments to non-generic method &apos;{0}&apos;!.
        /// </summary>
        public static string GenericArgsToNonGenericMethod {
            get {
                return ResourceManager.GetString("GenericArgsToNonGenericMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3045: Generic argument &apos;{0}&apos; could not be resolved!.
        /// </summary>
        public static string GenericArgumentNotResolved {
            get {
                return ResourceManager.GetString("GenericArgumentNotResolved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3046: Type &apos;{0}&apos; cannot be used as value for generic argument &apos;{1}&apos; of type &apos;{2}&apos; because it is not a reference type!.
        /// </summary>
        public static string GenericClassConstraintViolated {
            get {
                return ResourceManager.GetString("GenericClassConstraintViolated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3047: Type &apos;{0}&apos; cannot be used as value for generic argument &apos;{1}&apos; of type &apos;{2}&apos; because it does not have a default constructor!.
        /// </summary>
        public static string GenericConstructorConstraintViolated {
            get {
                return ResourceManager.GetString("GenericConstructorConstraintViolated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3048: Generic argument &apos;{0}&apos; was has hint type &apos;{1}&apos;, but inferred type was &apos;{2}&apos;!.
        /// </summary>
        public static string GenericHintMismatch {
            get {
                return ResourceManager.GetString("GenericHintMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3049: Cannot resolve arguments of &apos;{0}&apos; using type &apos;{1}&apos;!.
        /// </summary>
        public static string GenericImplementationWrongType {
            get {
                return ResourceManager.GetString("GenericImplementationWrongType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3050: Type &apos;{0}&apos; cannot be used as value for generic argument &apos;{1}&apos; of type &apos;{2}&apos; because it does not implement class or interface &apos;{3}&apos;!.
        /// </summary>
        public static string GenericInheritanceConstraintViolated {
            get {
                return ResourceManager.GetString("GenericInheritanceConstraintViolated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3051: Cannot infer argument types of &apos;{0}&apos;: type &apos;{1}&apos; implements multiple matching overrides!.
        /// </summary>
        public static string GenericInterfaceMultipleImplementations {
            get {
                return ResourceManager.GetString("GenericInterfaceMultipleImplementations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3052: Type &apos;{0}&apos; does not implement any kind of interface &apos;{1}&apos;!.
        /// </summary>
        public static string GenericInterfaceNotImplemented {
            get {
                return ResourceManager.GetString("GenericInterfaceNotImplemented", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3053: Generic parameter &apos;{0}&apos; was not found!.
        /// </summary>
        public static string GenericParameterNotFound {
            get {
                return ResourceManager.GetString("GenericParameterNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3054: Type &apos;{0}&apos; cannot be used as value for generic argument &apos;{1}&apos; of type &apos;{2}&apos; because it is not a value type!.
        /// </summary>
        public static string GenericStructConstraintViolated {
            get {
                return ResourceManager.GetString("GenericStructConstraintViolated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3055: Global property &apos;{0}&apos; has no getter!.
        /// </summary>
        public static string GlobalPropertyNoGetter {
            get {
                return ResourceManager.GetString("GlobalPropertyNoGetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3056: Global property &apos;{0}&apos; has no setter!.
        /// </summary>
        public static string GlobalPropertyNoSetter {
            get {
                return ResourceManager.GetString("GlobalPropertyNoSetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3057: Cannot assign a value of type &apos;{0}&apos; to a global property of type &apos;{1}&apos;! An explicit cast might be required..
        /// </summary>
        public static string GlobalPropertyTypeMismatch {
            get {
                return ResourceManager.GetString("GlobalPropertyTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3058: &apos;{0}&apos; is a constant and cannot be assigned after definition!.
        /// </summary>
        public static string IdentifierIsConstant {
            get {
                return ResourceManager.GetString("IdentifierIsConstant", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3059: No local variable or global parameterless function named &apos;{0}&apos; was found!.
        /// </summary>
        public static string IdentifierNotFound {
            get {
                return ResourceManager.GetString("IdentifierNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3060: Cannot assign a value of type &apos;{0}&apos; to a variable of type &apos;{1}&apos;! An explicit cast might be required..
        /// </summary>
        public static string IdentifierTypeMismatch {
            get {
                return ResourceManager.GetString("IdentifierTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3061: Cannot implicitly convert an object of type &apos;{0}&apos; to required type &apos;{1}&apos;!.
        /// </summary>
        public static string ImplicitCastImpossible {
            get {
                return ResourceManager.GetString("ImplicitCastImpossible", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3062: Entities cannot be imported into a saveable assembly!.
        /// </summary>
        public static string ImportIntoSaveableAssembly {
            get {
                return ResourceManager.GetString("ImportIntoSaveableAssembly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3063: Only public, static, non-generic methods can be imported!.
        /// </summary>
        public static string ImportUnsupportedMethod {
            get {
                return ResourceManager.GetString("ImportUnsupportedMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3064: Indexer is ambigious! At least two cases apply:{3}{0}[{1}]{3}{0}[{2}].
        /// </summary>
        public static string IndexAmbigious {
            get {
                return ResourceManager.GetString("IndexAmbigious", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3065: Cannot use a custom indexer of type &apos;{0}&apos; as a ref parameter, because it returns &apos;{1}&apos; which is valuetype!.
        /// </summary>
        public static string IndexerValuetypeRef {
            get {
                return ResourceManager.GetString("IndexerValuetypeRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3066: Type &apos;{0}&apos; has no index getter that accepts an index of type &apos;{1}&apos;!.
        /// </summary>
        public static string IndexGetterNotFound {
            get {
                return ResourceManager.GetString("IndexGetterNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3067: Type &apos;{0}&apos; has no index setter that accepts an index of type &apos;{1}&apos;!.
        /// </summary>
        public static string IndexSetterNotFound {
            get {
                return ResourceManager.GetString("IndexSetterNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3068: Lambda argument of type &apos;{0}&apos; contains unresolved generic references! Please specify the argument type explicitly..
        /// </summary>
        public static string LambdaArgGenericsUnresolved {
            get {
                return ResourceManager.GetString("LambdaArgGenericsUnresolved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3069: Type of argument &apos;{0}&apos; could not be inferred from usage! Please specify the type explicitly..
        /// </summary>
        public static string LambdaArgTypeUnknown {
            get {
                return ResourceManager.GetString("LambdaArgTypeUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3150: Delegate expects {0} arguments, but specified lambda expression accepts {1}!.
        /// </summary>
        public static string LambdaArgumentsCountMismatch {
            get {
                return ResourceManager.GetString("LambdaArgumentsCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3070: Lambda is used as delegate &apos;{0}&apos;, but its return type &apos;{1}&apos; cannot be casted to desired return type &apos;{2}&apos;!.
        /// </summary>
        public static string LambdaReturnTypeMismatch {
            get {
                return ResourceManager.GetString("LambdaReturnTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3071: Lambda return type cannot be inferred! Please use type casting to specify type..
        /// </summary>
        public static string LambdaReturnTypeUnknown {
            get {
                return ResourceManager.GetString("LambdaReturnTypeUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3072: Cannot add object of type &apos;{0}&apos; to List&lt;{1}&gt;!.
        /// </summary>
        public static string ListElementTypeMismatch {
            get {
                return ResourceManager.GetString("ListElementTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3073: List initializer must contain at least one object! Use explicit constructor to create an empty list..
        /// </summary>
        public static string ListEmpty {
            get {
                return ResourceManager.GetString("ListEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3074: List type cannot be inferred! Use type casting to specify element types..
        /// </summary>
        public static string ListTypeUnknown {
            get {
                return ResourceManager.GetString("ListTypeUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3075: Location: {0}.
        /// </summary>
        public static string Location {
            get {
                return ResourceManager.GetString("Location", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3076: Location: {0} ... {1}.
        /// </summary>
        public static string LocationSpan {
            get {
                return ResourceManager.GetString("LocationSpan", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3077: A method named &apos;{0}&apos; in type &apos;{1}&apos; with identical set of arguments has already been defined!.
        /// </summary>
        public static string MethodRedefinition {
            get {
                return ResourceManager.GetString("MethodRedefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3078: Cannot use a method as a ref parameter!.
        /// </summary>
        public static string MethodRef {
            get {
                return ResourceManager.GetString("MethodRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3134: Cannot infer common type if any of the expressions is &apos;Unit&apos; or &apos;Void&apos;!.
        /// </summary>
        public static string NoCommonType {
            get {
                return ResourceManager.GetString("NoCommonType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3051: No static public methods named &apos;{0}&apos; found in type &apos;{1}&apos;!.
        /// </summary>
        public static string NoOverloads {
            get {
                return ResourceManager.GetString("NoOverloads", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3079: Cannot apply operator &apos;{0}&apos; to arguments of types &apos;{1}&apos; and &apos;{2}&apos;!.
        /// </summary>
        public static string OperatorBinaryTypesMismatch {
            get {
                return ResourceManager.GetString("OperatorBinaryTypesMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3080: Cannot apply apply math operations to arguments of different signedness!.
        /// </summary>
        public static string OperatorTypesSignednessMismatch {
            get {
                return ResourceManager.GetString("OperatorTypesSignednessMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3081: Cannot apply operator &apos;{0}&apos; to argument of type &apos;{1}&apos;!.
        /// </summary>
        public static string OperatorUnaryTypeMismatch {
            get {
                return ResourceManager.GetString("OperatorUnaryTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3082: A parameterless constructor must be invoked by applying a () to it!.
        /// </summary>
        public static string ParameterlessConstructorParens {
            get {
                return ResourceManager.GetString("ParameterlessConstructorParens", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3135: Array pattern cannot contain more than one subsequence defined with ellipsis!.
        /// </summary>
        public static string PatternArraySubsequences {
            get {
                return ResourceManager.GetString("PatternArraySubsequences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3131: Pattern contains duplicate binding to name &apos;{0}&apos;!.
        /// </summary>
        public static string PatternNameDuplicated {
            get {
                return ResourceManager.GetString("PatternNameDuplicated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3132: Pattern binding mismatched: not all alternatives contain definition for &apos;{0}&apos;! Make sure all pattern alternatives contain the identical set of binding names and their corresponding types..
        /// </summary>
        public static string PatternNameSetMismatch {
            get {
                return ResourceManager.GetString("PatternNameSetMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3133: Pattern binding mismatched: binding to &apos;{0}&apos; is inferred to have different types (&apos;{1}&apos; and &apos;{2}&apos;) in alternatives..
        /// </summary>
        public static string PatternNameTypeMismatch {
            get {
                return ResourceManager.GetString("PatternNameTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3139: Type &apos;{0}&apos; must be a record defined in the script to be used in this pattern!.
        /// </summary>
        public static string PatternNotValidRecord {
            get {
                return ResourceManager.GetString("PatternNotValidRecord", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3138: Type &apos;{0}&apos; must be a type defined in the script to be used in this pattern!.
        /// </summary>
        public static string PatternNotValidType {
            get {
                return ResourceManager.GetString("PatternNotValidType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3141: Range pattern limits must be numeric constants!.
        /// </summary>
        public static string PatternRangeNotNumeric {
            get {
                return ResourceManager.GetString("PatternRangeNotNumeric", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3143: Duplicate pattern for field &apos;{0}&apos;!.
        /// </summary>
        public static string PatternRecordFieldDuplicated {
            get {
                return ResourceManager.GetString("PatternRecordFieldDuplicated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3140: Record &apos;{0}&apos; does not have a field named &apos;{1}&apos;!.
        /// </summary>
        public static string PatternRecordNoField {
            get {
                return ResourceManager.GetString("PatternRecordNoField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3142: Subsequence is only allowed for IEnumerable if it is the last element of the pattern!.
        /// </summary>
        public static string PatternSubsequenceLocation {
            get {
                return ResourceManager.GetString("PatternSubsequenceLocation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3129: Tuple pattern must have at lease 1 element!.
        /// </summary>
        public static string PatternTupleTooFewArgs {
            get {
                return ResourceManager.GetString("PatternTupleTooFewArgs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3128: Tuple pattern cannot have more than 7 elements!.
        /// </summary>
        public static string PatternTupleTooManyArgs {
            get {
                return ResourceManager.GetString("PatternTupleTooManyArgs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3136: Expression of type &apos;{0}&apos; can never be of type &apos;{1}&apos;!.
        /// </summary>
        public static string PatternTypeMatchImpossible {
            get {
                return ResourceManager.GetString("PatternTypeMatchImpossible", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3130: Pattern cannot be applied to type &apos;{0}&apos;, because it is incompatible with expected type &apos;{1}&apos;!.
        /// </summary>
        public static string PatternTypeMismatch {
            get {
                return ResourceManager.GetString("PatternTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3140: Type &apos;{0}&apos; does not have a tag!.
        /// </summary>
        public static string PatternTypeNoTag {
            get {
                return ResourceManager.GetString("PatternTypeNoTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3137: Pattern is unreachable because a catch-all pattern is already defined before!.
        /// </summary>
        public static string PatternUnreachable {
            get {
                return ResourceManager.GetString("PatternUnreachable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3083: Property #{0} has no getter!.
        /// </summary>
        public static string PropertyIdNoGetter {
            get {
                return ResourceManager.GetString("PropertyIdNoGetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3084: Property #{0} has no setter!.
        /// </summary>
        public static string PropertyIdNoSetter {
            get {
                return ResourceManager.GetString("PropertyIdNoSetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3085: Property #{0} does not exist!.
        /// </summary>
        public static string PropertyIdNotFound {
            get {
                return ResourceManager.GetString("PropertyIdNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3086: Property &apos;{0}&apos; has already been imported!.
        /// </summary>
        public static string PropertyImported {
            get {
                return ResourceManager.GetString("PropertyImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3087: Property &apos;{0}.{1}&apos; does not have a getter!.
        /// </summary>
        public static string PropertyNoGetter {
            get {
                return ResourceManager.GetString("PropertyNoGetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3088: Property &apos;{0}.{1}&apos; does not have a setter!.
        /// </summary>
        public static string PropertyNoSetter {
            get {
                return ResourceManager.GetString("PropertyNoSetter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3089: Cannot use property &apos;{0}.{1}&apos; as a ref parameter, because it returns &apos;{2}&apos; which is valuetype!.
        /// </summary>
        public static string PropertyValuetypeRef {
            get {
                return ResourceManager.GetString("PropertyValuetypeRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3090: Function &apos;{0}&apos; cannot be marked as pure because it does not return a value!.
        /// </summary>
        public static string PureFunctionReturnUnit {
            get {
                return ResourceManager.GetString("PureFunctionReturnUnit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3091: Function &apos;{0}&apos; cannot be marked as pure because it contains more than 7 arguments!.
        /// </summary>
        public static string PureFunctionTooManyArgs {
            get {
                return ResourceManager.GetString("PureFunctionTooManyArgs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3092: Argument {0} requires a reference of type &apos;{1}&apos;!.
        /// </summary>
        public static string ReferenceArgExpected {
            get {
                return ResourceManager.GetString("ReferenceArgExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3093: Cannot use reference as a value for non-reference argument!.
        /// </summary>
        public static string ReferenceArgUnexpected {
            get {
                return ResourceManager.GetString("ReferenceArgUnexpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3147: Converter type &apos;{0}&apos; is incompatible because it doesn&apos;t provide a Parse(string) method!.
        /// </summary>
        public static string RegexConverterTypeIncompatible {
            get {
                return ResourceManager.GetString("RegexConverterTypeIncompatible", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3146: Converter type &apos;{0}&apos; does not exist!.
        /// </summary>
        public static string RegexConverterTypeNotFound {
            get {
                return ResourceManager.GetString("RegexConverterTypeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3145: Duplicate regex modifier &apos;{0}&apos;!.
        /// </summary>
        public static string RegexDuplicateModifier {
            get {
                return ResourceManager.GetString("RegexDuplicateModifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3148: Syntax error in regular expression!.
        /// </summary>
        public static string RegexSyntaxError {
            get {
                return ResourceManager.GetString("RegexSyntaxError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3144: Unknown regex modifier &apos;{0}&apos;!.
        /// </summary>
        public static string RegexUnknownModifier {
            get {
                return ResourceManager.GetString("RegexUnknownModifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3094: Cannot invoke function &apos;{0}&apos; because it is reserved for internal purposes..
        /// </summary>
        public static string ReservedFunctionInvocation {
            get {
                return ResourceManager.GetString("ReservedFunctionInvocation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3095: Cannot define a function named &apos;{0}&apos; because it is reserved for internal purposes..
        /// </summary>
        public static string ReservedFunctionRedefinition {
            get {
                return ResourceManager.GetString("ReservedFunctionRedefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3096: Function of type &apos;{0}&apos; cannot return an expression of type &apos;{1}&apos;!.
        /// </summary>
        public static string ReturnTypeMismatch {
            get {
                return ResourceManager.GetString("ReturnTypeMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3097: Type &apos;{0}&apos; cannot be used in the script due to safe mode settings!.
        /// </summary>
        public static string SafeModeIllegalType {
            get {
                return ResourceManager.GetString("SafeModeIllegalType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3098: Expression is expected! An exception can only be rethrown from a catch clause..
        /// </summary>
        public static string ThrowArgumentExpected {
            get {
                return ResourceManager.GetString("ThrowArgumentExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3099: Type &apos;{0}&apos; cannot be used in throw statement because it does not derive from System.Exception!.
        /// </summary>
        public static string ThrowTypeNotException {
            get {
                return ResourceManager.GetString("ThrowTypeNotException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3100: Tuple must contain at least one object!.
        /// </summary>
        public static string TupleNoArgs {
            get {
                return ResourceManager.GetString("TupleNoArgs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3101: Tuples cannot contain more than 8 objects! Use a structure or a nested tuple instead..
        /// </summary>
        public static string TupleTooManyArgs {
            get {
                return ResourceManager.GetString("TupleTooManyArgs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3102: Cannot create an instance of type &apos;{0}&apos; because it is abstract!.
        /// </summary>
        public static string TypeAbstract {
            get {
                return ResourceManager.GetString("TypeAbstract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3103: Type arguments cannot be applied to &apos;{0}.{1}&apos; because it is not a method!.
        /// </summary>
        public static string TypeArgumentsForNonMethod {
            get {
                return ResourceManager.GetString("TypeArgumentsForNonMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3104: Type &apos;{0}&apos; has more than one suitable constructor! Please use type casting to specify the exact override..
        /// </summary>
        public static string TypeConstructorAmbiguos {
            get {
                return ResourceManager.GetString("TypeConstructorAmbiguos", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3105: Type &apos;{0}&apos; does not have a constructor accepting given arguments!.
        /// </summary>
        public static string TypeConstructorNotFound {
            get {
                return ResourceManager.GetString("TypeConstructorNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3106: Type &apos;{0}&apos; has already been defined!.
        /// </summary>
        public static string TypeDefined {
            get {
                return ResourceManager.GetString("TypeDefined", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3107: Type &apos;{0}&apos; does not have any field, property or method called &apos;{1}&apos;!.
        /// </summary>
        public static string TypeIdentifierNotFound {
            get {
                return ResourceManager.GetString("TypeIdentifierNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3108: Cannot create an instance of interface &apos;{0}&apos;!.
        /// </summary>
        public static string TypeInterface {
            get {
                return ResourceManager.GetString("TypeInterface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3109: Ambigious type reference: type &apos;{0}&apos; is found in the following namespaces:{5}{1} in assembly {2}{5}{3} in assembly {4}.
        /// </summary>
        public static string TypeIsAmbiguous {
            get {
                return ResourceManager.GetString("TypeIsAmbiguous", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3110: Type &apos;{0}&apos; has more than one suitable override of &apos;{1}&apos;! Please specify type arguments..
        /// </summary>
        public static string TypeMethodAmbiguous {
            get {
                return ResourceManager.GetString("TypeMethodAmbiguous", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3111: Type &apos;{0}&apos; has more than one suitable override of &apos;{1}&apos;! Please use type casting to specify the exact override..
        /// </summary>
        public static string TypeMethodInvocationAmbiguous {
            get {
                return ResourceManager.GetString("TypeMethodInvocationAmbiguous", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3112: Type &apos;{0}&apos; has no method named &apos;{1}&apos; and no extension method accepting given arguments was found!.
        /// </summary>
        public static string TypeMethodNotFound {
            get {
                return ResourceManager.GetString("TypeMethodNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3113: Cannot pass arguments to expression of type &apos;{0}&apos;, because it is not callable!.
        /// </summary>
        public static string TypeNotCallable {
            get {
                return ResourceManager.GetString("TypeNotCallable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3114: Type &apos;{0}&apos; could not be resolved!.
        /// </summary>
        public static string TypeNotFound {
            get {
                return ResourceManager.GetString("TypeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3115: Type &apos;{0}&apos; cannot be used in a boolean context!.
        /// </summary>
        public static string TypeNotImplicitlyBoolean {
            get {
                return ResourceManager.GetString("TypeNotImplicitlyBoolean", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3116: Type &apos;{0}&apos; is not iterable!.
        /// </summary>
        public static string TypeNotIterable {
            get {
                return ResourceManager.GetString("TypeNotIterable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3117: Type &apos;{0}&apos; is not numeric!.
        /// </summary>
        public static string TypeNotNumeric {
            get {
                return ResourceManager.GetString("TypeNotNumeric", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3118: Type &apos;{0}&apos; does not contain a field or a property named &apos;{1}&apos;!.
        /// </summary>
        public static string TypeSettableIdentifierNotFound {
            get {
                return ResourceManager.GetString("TypeSettableIdentifierNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3119: Types &apos;{0}&apos; and &apos;{1}&apos; cannot be compared!.
        /// </summary>
        public static string TypesIncomparable {
            get {
                return ResourceManager.GetString("TypesIncomparable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3120: Type &apos;{0}&apos; has no method named &apos;{1}&apos;!.
        /// </summary>
        public static string TypeStaticMethodNotFound {
            get {
                return ResourceManager.GetString("TypeStaticMethodNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3121: The &apos;_&apos; identifier is special and cannot be used for arguments, variable names, and any other user-defined entities!.
        /// </summary>
        public static string UnderscoreName {
            get {
                return ResourceManager.GetString("UnderscoreName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3122: The &apos;_&apos; identifier is not allowed in this context!.
        /// </summary>
        public static string UnderscoreNameUsed {
            get {
                return ResourceManager.GetString("UnderscoreNameUsed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3123: A variable named &apos;{0}&apos; is already defined!.
        /// </summary>
        public static string VariableDefined {
            get {
                return ResourceManager.GetString("VariableDefined", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3124: A variable named &apos;{0}&apos; does not exist in the scope!.
        /// </summary>
        public static string VariableNotFound {
            get {
                return ResourceManager.GetString("VariableNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3125: Cannot use &apos;...&apos; argument modified in a lambda!.
        /// </summary>
        public static string VariadicArgumentLambda {
            get {
                return ResourceManager.GetString("VariadicArgumentLambda", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3126: An argument with &apos;...&apos; modifier must be the last one!.
        /// </summary>
        public static string VariadicArgumentNotLast {
            get {
                return ResourceManager.GetString("VariadicArgumentNotLast", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LE3127: Cannot create an instance of Unit or Void types!.
        /// </summary>
        public static string VoidTypeDefault {
            get {
                return ResourceManager.GetString("VoidTypeDefault", resourceCulture);
            }
        }
    }
}
